package com.easysettle.data

import android.content.Context
import android.util.Log
import com.easysettle.model.Product
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import java.io.File
import java.io.FileReader
import java.io.FileWriter
import java.io.IOException
import java.util.concurrent.locks.ReentrantReadWriteLock

/**
 * 商品数据管理器
 * 负责商品数据的存储、读取和管理
 */
class ProductDataManager private constructor(context: Context) {
    // 数据文件路径
    private val dataFile: File
    // Gson实例，用于JSON序列化和反序列化
    private val gson = Gson()
    // 读写锁，确保线程安全
    private val lock = ReentrantReadWriteLock()

    companion object {
        // 数据文件名
        private const val DATA_FILENAME = "products.json"
        // 日志标签
        private const val TAG = "ProductDataManager"
        // 单例实例
        @Volatile
        private var instance: ProductDataManager? = null

        /**
         * 获取单例实例
         */
        fun getInstance(context: Context): ProductDataManager {
            return instance ?: synchronized(this) {
                instance ?: ProductDataManager(context).also {
                    instance = it
                }
            }
        }
    }

    init {
        // 初始化数据文件
        dataFile = File(context.filesDir, DATA_FILENAME)
        if (!dataFile.exists()) {
            try {
                dataFile.createNewFile()
                // 创建空的商品列表文件
                saveProducts(emptyList())
            } catch (e: IOException) {
                Log.e(TAG, "无法创建数据文件", e)
            }
        }
    }

    /**
     * 获取所有商品
     */
    fun getAllProducts(): List<Product> {
        lock.readLock().lock()
        try {
            return readProducts()
        } catch (e: Exception) {
            Log.e(TAG, "读取商品数据失败", e)
            return emptyList()
        } finally {
            lock.readLock().unlock()
        }
    }

    /**
     * 根据ID查找商品
     * 支持数字ID的模糊匹配，例如输入"001"可以找到ID为"1"的商品
     */
    fun getProductById(id: String): Product? {
        return getAllProducts().find { 
            // 先尝试字符串直接匹配
            it.id == id || 
            // 再尝试将双方转为数字进行比较
            try {
                it.id.toInt() == id.toInt()
            } catch (e: NumberFormatException) {
                false
            }
        }
    }

    /**
     * 根据条形码查找商品
     */
    fun getProductByBarcode(barcode: String): Product? {
        return getAllProducts().find { it.barcode == barcode }
    }

    /**
     * 根据ID或名称模糊查询商品
     */
    fun searchProducts(query: String): List<Product> {
        val lowercaseQuery = query.toLowerCase()
        return getAllProducts().filter { product ->
            // ID模糊匹配（包括数字ID的匹配）
            product.id.contains(lowercaseQuery) || 
            try {
                // 尝试数字ID的匹配
                val queryInt = query.toInt()
                val productIdInt = product.id.toInt()
                productIdInt == queryInt
            } catch (e: NumberFormatException) {
                false
            } ||
            // 名称模糊匹配
            product.name.toLowerCase().contains(lowercaseQuery)
        }
    }

    /**
     * 查找下一个可用的商品ID
     */
    fun getNextAvailableId(): String {
        val products = getAllProducts()
        val maxId = products.maxOfOrNull { it.id.toIntOrNull() ?: 0 } ?: 0
        return (maxId + 1).toString()
    }

    /**
     * 添加新商品
     */
    fun addProduct(product: Product): Boolean {
        lock.writeLock().lock()
        try {
            val products = readProducts().toMutableList()
            // 检查是否已存在相同ID的商品
            if (products.any { it.id == product.id }) {
                Log.w(TAG, "添加商品失败：ID已存在")
                return false
            }
            products.add(product)
            return saveProducts(products)
        } catch (e: Exception) {
            Log.e(TAG, "添加商品失败", e)
            return false
        } finally {
            lock.writeLock().unlock()
        }
    }

    /**
     * 更新商品信息
     */
    fun updateProduct(updatedProduct: Product): Boolean {
        lock.writeLock().lock()
        try {
            val products = readProducts().toMutableList()
            val index = products.indexOfFirst { it.id == updatedProduct.id }
            if (index == -1) {
                Log.w(TAG, "更新商品失败：商品不存在")
                return false
            }
            products[index] = updatedProduct
            return saveProducts(products)
        } catch (e: Exception) {
            Log.e(TAG, "更新商品失败", e)
            return false
        } finally {
            lock.writeLock().unlock()
        }
    }

    /**
     * 删除商品
     */
    fun deleteProduct(productId: String): Boolean {
        lock.writeLock().lock()
        try {
            val products = readProducts().toMutableList()
            val removed = products.removeIf { it.id == productId }
            if (removed) {
                return saveProducts(products)
            }
            Log.w(TAG, "删除商品失败：商品不存在")
            return false
        } catch (e: Exception) {
            Log.e(TAG, "删除商品失败", e)
            return false
        } finally {
            lock.writeLock().unlock()
        }
    }

    /**
     * 从文件读取商品数据
     */
    private fun readProducts(): List<Product> {
        try {
            if (!dataFile.exists() || dataFile.length() == 0L) {
                return emptyList()
            }
            FileReader(dataFile).use { reader ->
                val type = object : TypeToken<List<Product>>() {}.type
                return gson.fromJson(reader, type) ?: emptyList()
            }
        } catch (e: Exception) {
            Log.e(TAG, "读取商品数据失败", e)
            return emptyList()
        }
    }

    /**
     * 将商品数据保存到文件
     */
    private fun saveProducts(products: List<Product>): Boolean {
        try {
            FileWriter(dataFile).use { writer ->
                gson.toJson(products, writer)
                return true
            }
        } catch (e: Exception) {
            Log.e(TAG, "保存商品数据失败", e)
            return false
        }
    }
}